home *** CD-ROM | disk | FTP | other *** search
/ Team Palmtops 7 / Palmtops_numero07.iso / WinCE / SDKWindowsCE / HandHeldPCPro30 / sdk.exe / Jupiter SDK / data1.cab / ATL / include / Atlconv.h < prev    next >
Encoding:
C/C++ Source or Header  |  1999-02-19  |  13.2 KB  |  374 lines
  1. // This is a part of the Active Template Library.
  2. // Copyright (C) 1996-1998 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Active Template Library Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Active Template Library product.
  10.  
  11. #ifndef __ATLCONV_H__
  12. #define __ATLCONV_H__
  13.  
  14. #ifndef __cplusplus
  15.     #error ATL requires C++ compilation (use a .cpp suffix)
  16. #endif
  17.  
  18. #include <atldef.h>
  19.  
  20. #ifndef _INC_MALLOC
  21. #include <malloc.h>
  22. #endif // _INC_MALLOC
  23.  
  24. #pragma pack(push,8)
  25.  
  26. #ifdef _CONVERSION_USES_THREAD_LOCALE
  27.     #ifndef _DEBUG
  28.         #define USES_CONVERSION int _convert; _convert; UINT _acp = GetACP(); _acp; LPCWSTR _lpw; _lpw; LPCSTR _lpa; _lpa
  29.     #else
  30.         #define USES_CONVERSION int _convert = 0; _convert; UINT _acp = GetACP(); _acp; LPCWSTR _lpw = NULL; _lpw; LPCSTR _lpa = NULL; _lpa
  31.     #endif
  32. #else
  33.     #ifndef _DEBUG
  34.         #define USES_CONVERSION int _convert; _convert; UINT _acp = CP_ACP; _acp; LPCWSTR _lpw; _lpw; LPCSTR _lpa; _lpa
  35.     #else
  36.         #define USES_CONVERSION int _convert = 0; _convert; UINT _acp = CP_ACP; _acp; LPCWSTR _lpw = NULL; _lpw; LPCSTR _lpa = NULL; _lpa
  37.     #endif
  38. #endif
  39.  
  40. #ifdef _WINGDI_
  41.     ATLAPI_(LPDEVMODEA) AtlDevModeW2A(LPDEVMODEA lpDevModeA, LPDEVMODEW lpDevModeW);
  42. #endif
  43.  
  44. /////////////////////////////////////////////////////////////////////////////
  45. // Global UNICODE<>ANSI translation helpers
  46. inline LPWSTR WINAPI AtlA2WHelper(LPWSTR lpw, LPCSTR lpa, int nChars, UINT acp)
  47. {
  48.     ATLASSERT(lpa != NULL);
  49.     ATLASSERT(lpw != NULL);
  50.     // verify that no illegal character present
  51.     // since lpw was allocated based on the size of lpa
  52.     // don't worry about the number of chars
  53.     lpw[0] = '\0';
  54.     MultiByteToWideChar(acp, 0, lpa, -1, lpw, nChars);
  55.     return lpw;
  56. }
  57.  
  58. inline LPSTR WINAPI AtlW2AHelper(LPSTR lpa, LPCWSTR lpw, int nChars, UINT acp)
  59. {
  60.     ATLASSERT(lpw != NULL);
  61.     ATLASSERT(lpa != NULL);
  62.     // verify that no illegal character present
  63.     // since lpa was allocated based on the size of lpw
  64.     // don't worry about the number of chars
  65.     lpa[0] = '\0';
  66.     WideCharToMultiByte(acp, 0, lpw, -1, lpa, nChars, NULL, NULL);
  67.     return lpa;
  68. }
  69. inline LPWSTR WINAPI AtlA2WHelper(LPWSTR lpw, LPCSTR lpa, int nChars)
  70. {
  71.     return AtlA2WHelper(lpw, lpa, nChars, CP_ACP);
  72. }
  73.  
  74. inline LPSTR WINAPI AtlW2AHelper(LPSTR lpa, LPCWSTR lpw, int nChars)
  75. {
  76.     return AtlW2AHelper(lpa, lpw, nChars, CP_ACP);
  77. }
  78.  
  79. #ifdef _CONVERSION_USES_THREAD_LOCALE
  80.     #ifdef ATLA2WHELPER
  81.         #undef ATLA2WHELPER
  82.         #undef ATLW2AHELPER
  83.     #endif
  84.     #define ATLA2WHELPER AtlA2WHelper
  85.     #define ATLW2AHELPER AtlW2AHelper
  86. #else
  87.     #ifndef ATLA2WHELPER
  88.         #define ATLA2WHELPER AtlA2WHelper
  89.         #define ATLW2AHELPER AtlW2AHelper
  90.     #endif
  91. #endif
  92.  
  93. #if defined(_WIN32_WCE)
  94. #define A2W(lpa) (\
  95.     ((LPCSTR)lpa == NULL) ? NULL : (\
  96.         _convert = (strlen(lpa)+1),\
  97.         ATLA2WHELPER((LPWSTR) alloca(_convert*2), lpa, _convert)))
  98. #else // _WIN32_WCE
  99. #ifdef _CONVERSION_USES_THREAD_LOCALE
  100.     #define A2W(lpa) (\
  101.         ((_lpa = lpa) == NULL) ? NULL : (\
  102.             _convert = (lstrlenA(_lpa)+1),\
  103.             ATLA2WHELPER((LPWSTR) alloca(_convert*2), _lpa, _convert, _acp)))
  104. #else
  105.     #define A2W(lpa) (\
  106.         ((_lpa = lpa) == NULL) ? NULL : (\
  107.             _convert = (lstrlenA(_lpa)+1),\
  108.             ATLA2WHELPER((LPWSTR) alloca(_convert*2), _lpa, _convert)))
  109. #endif
  110. #endif // _WIN32_WCE
  111.  
  112. #ifdef _CONVERSION_USES_THREAD_LOCALE
  113.     #define W2A(lpw) (\
  114.         ((_lpw = lpw) == NULL) ? NULL : (\
  115.             _convert = (lstrlenW(_lpw)+1)*2,\
  116.             ATLW2AHELPER((LPSTR) alloca(_convert), _lpw, _convert, _acp)))
  117. #else
  118.     #define W2A(lpw) (\
  119.         ((_lpw = lpw) == NULL) ? NULL : (\
  120.             _convert = (lstrlenW(_lpw)+1)*2,\
  121.             ATLW2AHELPER((LPSTR) alloca(_convert), _lpw, _convert)))
  122. #endif
  123.  
  124. #define A2CW(lpa) ((LPCWSTR)A2W(lpa))
  125. #define W2CA(lpw) ((LPCSTR)W2A(lpw))
  126.  
  127. #if defined(_UNICODE)
  128. // in these cases the default (TCHAR) is the same as OLECHAR
  129.     inline size_t ocslen(LPCOLESTR x) { return lstrlenW(x); }
  130.     inline OLECHAR* ocscpy(LPOLESTR dest, LPCOLESTR src) { return lstrcpyW(dest, src); }
  131.     inline OLECHAR* ocscat(LPOLESTR dest, LPCOLESTR src) { return lstrcatW(dest, src); }
  132.     inline LPCOLESTR T2COLE(LPCTSTR lp) { return lp; }
  133.     inline LPCTSTR OLE2CT(LPCOLESTR lp) { return lp; }
  134.     inline LPOLESTR T2OLE(LPTSTR lp) { return lp; }
  135.     inline LPTSTR OLE2T(LPOLESTR lp) { return lp; }
  136.     inline LPOLESTR CharNextO(LPCOLESTR lp) {return CharNextW(lp);}
  137. #elif defined(OLE2ANSI)
  138. // in these cases the default (TCHAR) is the same as OLECHAR
  139.     inline size_t ocslen(LPCOLESTR x) { return lstrlen(x); }
  140.     inline OLECHAR* ocscpy(LPOLESTR dest, LPCOLESTR src) { return lstrcpy(dest, src); }
  141.     inline OLECHAR* ocscat(LPOLESTR dest, LPCOLESTR src) { return ocscpy(dest+ocslen(dest), src); }
  142.     inline LPCOLESTR T2COLE(LPCTSTR lp) { return lp; }
  143.     inline LPCTSTR OLE2CT(LPCOLESTR lp) { return lp; }
  144.     inline LPOLESTR T2OLE(LPTSTR lp) { return lp; }
  145.     inline LPTSTR OLE2T(LPOLESTR lp) { return lp; }
  146.     inline LPOLESTR CharNextO(LPCOLESTR lp) {return CharNext(lp);}
  147. #else
  148.     inline size_t ocslen(LPCOLESTR x) { return lstrlenW(x); }
  149.     //lstrcpyW doesn't work on Win95, so we do this
  150.     inline OLECHAR* ocscpy(LPOLESTR dest, LPCOLESTR src)
  151.     {return (LPOLESTR) memcpy(dest, src, (lstrlenW(src)+1)*sizeof(WCHAR));}
  152.     inline OLECHAR* ocscat(LPOLESTR dest, LPCOLESTR src) { return ocscpy(dest+ocslen(dest), src); }
  153.     //CharNextW doesn't work on Win95 so we use this
  154.     #define T2COLE(lpa) A2CW(lpa)
  155.     #define T2OLE(lpa) A2W(lpa)
  156.     #define OLE2CT(lpo) W2CA(lpo)
  157.     #define OLE2T(lpo) W2A(lpo)
  158.     inline LPOLESTR CharNextO(LPCOLESTR lp) {return (LPOLESTR) ((*lp) ? (lp+1) : lp);}
  159. #endif
  160.  
  161. #ifdef OLE2ANSI
  162.     inline LPOLESTR A2OLE(LPSTR lp) { return lp;}
  163.     inline LPSTR OLE2A(LPOLESTR lp) { return lp;}
  164.     #define W2OLE W2A
  165.     #define OLE2W A2W
  166.     inline LPCOLESTR A2COLE(LPCSTR lp) { return lp;}
  167.     inline LPCSTR OLE2CA(LPCOLESTR lp) { return lp;}
  168.     #define W2COLE W2CA
  169.     #define OLE2CW A2CW
  170. #else
  171.     inline LPOLESTR W2OLE(LPWSTR lp) { return lp; }
  172.     inline LPWSTR OLE2W(LPOLESTR lp) { return lp; }
  173.     #define A2OLE A2W
  174.     #define OLE2A W2A
  175.     inline LPCOLESTR W2COLE(LPCWSTR lp) { return lp; }
  176.     inline LPCWSTR OLE2CW(LPCOLESTR lp) { return lp; }
  177.     #define A2COLE A2CW
  178.     #define OLE2CA W2CA
  179. #endif
  180.  
  181. #ifdef _UNICODE
  182.     #define T2A W2A
  183.     #define A2T A2W
  184.     inline LPWSTR T2W(LPTSTR lp) { return lp; }
  185.     inline LPTSTR W2T(LPWSTR lp) { return lp; }
  186.     #define T2CA W2CA
  187.     #define A2CT A2CW
  188.     inline LPCWSTR T2CW(LPCTSTR lp) { return lp; }
  189.     inline LPCTSTR W2CT(LPCWSTR lp) { return lp; }
  190. #else
  191.     #define T2W A2W
  192.     #define W2T W2A
  193.     inline LPSTR T2A(LPTSTR lp) { return lp; }
  194.     inline LPTSTR A2T(LPSTR lp) { return lp; }
  195.     #define T2CW A2CW
  196.     #define W2CT W2CA
  197.     inline LPCSTR T2CA(LPCTSTR lp) { return lp; }
  198.     inline LPCTSTR A2CT(LPCSTR lp) { return lp; }
  199. #endif
  200.  
  201. inline BSTR A2WBSTR(LPCSTR lp, int nLen = -1)
  202. {
  203.     USES_CONVERSION;
  204.     BSTR str = NULL;
  205.     int nConvertedLen = MultiByteToWideChar(_acp, 0, lp,
  206.         nLen, NULL, NULL)-1;
  207.     str = ::SysAllocStringLen(NULL, nConvertedLen);
  208.     if (str != NULL)
  209.     {
  210.         MultiByteToWideChar(_acp, 0, lp, -1,
  211.             str, nConvertedLen);
  212.     }
  213.     return str;
  214. }
  215.  
  216. inline BSTR OLE2BSTR(LPCOLESTR lp) {return ::SysAllocString(lp);}
  217. #if defined(_UNICODE)
  218. // in these cases the default (TCHAR) is the same as OLECHAR
  219.     inline BSTR T2BSTR(LPCTSTR lp) {return ::SysAllocString(lp);}
  220.     inline BSTR A2BSTR(LPCSTR lp) {USES_CONVERSION; return A2WBSTR(lp);}
  221.     inline BSTR W2BSTR(LPCWSTR lp) {return ::SysAllocString(lp);}
  222. #elif defined(OLE2ANSI)
  223. // in these cases the default (TCHAR) is the same as OLECHAR
  224.     inline BSTR T2BSTR(LPCTSTR lp) {return ::SysAllocString(lp);}
  225.     inline BSTR A2BSTR(LPCSTR lp) {return ::SysAllocString(lp);}
  226.     inline BSTR W2BSTR(LPCWSTR lp) {USES_CONVERSION; return ::SysAllocString(W2COLE(lp));}
  227. #else
  228.     inline BSTR T2BSTR(LPCTSTR lp) {USES_CONVERSION; return A2WBSTR(lp);}
  229.     inline BSTR A2BSTR(LPCSTR lp) {USES_CONVERSION; return A2WBSTR(lp);}
  230.     inline BSTR W2BSTR(LPCWSTR lp) {return ::SysAllocString(lp);}
  231. #endif
  232.  
  233. #ifdef _WINGDI_
  234. /////////////////////////////////////////////////////////////////////////////
  235. // Global UNICODE<>ANSI translation helpers
  236. inline LPDEVMODEW AtlDevModeA2W(LPDEVMODEW lpDevModeW, LPDEVMODEA lpDevModeA)
  237. {
  238.     USES_CONVERSION;
  239.     if (lpDevModeA == NULL)
  240.         return NULL;
  241.     ATLASSERT(lpDevModeW != NULL);
  242.     AtlA2WHelper(lpDevModeW->dmDeviceName, (LPCSTR)lpDevModeA->dmDeviceName, 32*sizeof(WCHAR), _acp);
  243.     memcpy(&lpDevModeW->dmSpecVersion, &lpDevModeA->dmSpecVersion,
  244.         offsetof(DEVMODEW, dmFormName) - offsetof(DEVMODEW, dmSpecVersion));
  245.     AtlA2WHelper(lpDevModeW->dmFormName, (LPCSTR)lpDevModeA->dmFormName, 32*sizeof(WCHAR), _acp);
  246.     memcpy(&lpDevModeW->dmLogPixels, &lpDevModeA->dmLogPixels,
  247.         sizeof(DEVMODEW) - offsetof(DEVMODEW, dmLogPixels));
  248.     if (lpDevModeA->dmDriverExtra != 0)
  249.         memcpy(lpDevModeW+1, lpDevModeA+1, lpDevModeA->dmDriverExtra);
  250.     lpDevModeW->dmSize = sizeof(DEVMODEW);
  251.     return lpDevModeW;
  252. }
  253.  
  254. inline LPTEXTMETRICW AtlTextMetricA2W(LPTEXTMETRICW lptmW, LPTEXTMETRICA lptmA)
  255. {
  256.     USES_CONVERSION;
  257.     if (lptmA == NULL)
  258.         return NULL;
  259.     ATLASSERT(lptmW != NULL);
  260.     memcpy(lptmW, lptmA, sizeof(LONG) * 11);
  261.     memcpy(&lptmW->tmItalic, &lptmA->tmItalic, sizeof(BYTE) * 5);
  262.     MultiByteToWideChar(_acp, 0, (LPCSTR)&lptmA->tmFirstChar, 1, &lptmW->tmFirstChar, 1);
  263.     MultiByteToWideChar(_acp, 0, (LPCSTR)&lptmA->tmLastChar, 1, &lptmW->tmLastChar, 1);
  264.     MultiByteToWideChar(_acp, 0, (LPCSTR)&lptmA->tmDefaultChar, 1, &lptmW->tmDefaultChar, 1);
  265.     MultiByteToWideChar(_acp, 0, (LPCSTR)&lptmA->tmBreakChar, 1, &lptmW->tmBreakChar, 1);
  266.     return lptmW;
  267. }
  268.  
  269. inline LPTEXTMETRICA AtlTextMetricW2A(LPTEXTMETRICA lptmA, LPTEXTMETRICW lptmW)
  270. {
  271.     USES_CONVERSION;
  272.     if (lptmW == NULL)
  273.         return NULL;
  274.     ATLASSERT(lptmA != NULL);
  275.     memcpy(lptmA, lptmW, sizeof(LONG) * 11);
  276.     memcpy(&lptmA->tmItalic, &lptmW->tmItalic, sizeof(BYTE) * 5);
  277.     WideCharToMultiByte(_acp, 0, &lptmW->tmFirstChar, 1, (LPSTR)&lptmA->tmFirstChar, 1, NULL, NULL);
  278.     WideCharToMultiByte(_acp, 0, &lptmW->tmLastChar, 1, (LPSTR)&lptmA->tmLastChar, 1, NULL, NULL);
  279.     WideCharToMultiByte(_acp, 0, &lptmW->tmDefaultChar, 1, (LPSTR)&lptmA->tmDefaultChar, 1, NULL, NULL);
  280.     WideCharToMultiByte(_acp, 0, &lptmW->tmBreakChar, 1, (LPSTR)&lptmA->tmBreakChar, 1, NULL, NULL);
  281.     return lptmA;
  282. }
  283.  
  284. #ifndef ATLDEVMODEA2W
  285. #define ATLDEVMODEA2W AtlDevModeA2W
  286. #define ATLDEVMODEW2A AtlDevModeW2A
  287. #define ATLTEXTMETRICA2W AtlTextMetricA2W
  288. #define ATLTEXTMETRICW2A AtlTextMetricW2A
  289. #endif
  290.  
  291. #define DEVMODEW2A(lpw)\
  292.     ((lpw == NULL) ? NULL : ATLDEVMODEW2A((LPDEVMODEA)alloca(sizeof(DEVMODEA)+lpw->dmDriverExtra), lpw))
  293. #define DEVMODEA2W(lpa)\
  294.     ((lpa == NULL) ? NULL : ATLDEVMODEA2W((LPDEVMODEW)alloca(sizeof(DEVMODEW)+lpa->dmDriverExtra), lpa))
  295. #define TEXTMETRICW2A(lptmw)\
  296.     ((lptmw == NULL) ? NULL : ATLTEXTMETRICW2A((LPTEXTMETRICA)alloca(sizeof(TEXTMETRICA)), lptmw))
  297. #define TEXTMETRICA2W(lptma)\
  298.     ((lptma == NULL) ? NULL : ATLTEXTMETRICA2W((LPTEXTMETRICW)alloca(sizeof(TEXTMETRICW)), lptma))
  299.  
  300. #ifdef OLE2ANSI
  301.     #define DEVMODEOLE DEVMODEA
  302.     #define LPDEVMODEOLE LPDEVMODEA
  303.     #define TEXTMETRICOLE TEXTMETRICA
  304.     #define LPTEXTMETRICOLE LPTEXTMETRICA
  305. #else
  306.     #define DEVMODEOLE DEVMODEW
  307.     #define LPDEVMODEOLE LPDEVMODEW
  308.     #define TEXTMETRICOLE TEXTMETRICW
  309.     #define LPTEXTMETRICOLE LPTEXTMETRICW
  310. #endif
  311.  
  312. #if defined(_UNICODE)
  313. // in these cases the default (TCHAR) is the same as OLECHAR
  314.     inline LPDEVMODEW DEVMODEOLE2T(LPDEVMODEOLE lp) { return lp; }
  315.     inline LPDEVMODEOLE DEVMODET2OLE(LPDEVMODEW lp) { return lp; }
  316.     inline LPTEXTMETRICW TEXTMETRICOLE2T(LPTEXTMETRICOLE lp) { return lp; }
  317.     inline LPTEXTMETRICOLE TEXTMETRICT2OLE(LPTEXTMETRICW lp) { return lp; }
  318. #elif defined(OLE2ANSI)
  319. // in these cases the default (TCHAR) is the same as OLECHAR
  320.     inline LPDEVMODE DEVMODEOLE2T(LPDEVMODEOLE lp) { return lp; }
  321.     inline LPDEVMODEOLE DEVMODET2OLE(LPDEVMODE lp) { return lp; }
  322.     inline LPTEXTMETRIC TEXTMETRICOLE2T(LPTEXTMETRICOLE lp) { return lp; }
  323.     inline LPTEXTMETRICOLE TEXTMETRICT2OLE(LPTEXTMETRIC lp) { return lp; }
  324. #else
  325.     #define DEVMODEOLE2T(lpo) DEVMODEW2A(lpo)
  326.     #define DEVMODET2OLE(lpa) DEVMODEA2W(lpa)
  327.     #define TEXTMETRICOLE2T(lptmw) TEXTMETRICW2A(lptmw)
  328.     #define TEXTMETRICT2OLE(lptma) TEXTMETRICA2W(lptma)
  329. #endif
  330.  
  331. #endif //_WINGDI_
  332.  
  333. #pragma pack(pop)
  334.  
  335. #ifndef _ATL_DLL_IMPL
  336. #ifndef _ATL_DLL
  337. #define _ATLCONV_IMPL
  338. #endif
  339. #endif
  340.  
  341. #endif // __ATLCONV_H__
  342.  
  343. /////////////////////////////////////////////////////////////////////////////
  344.  
  345. #ifdef _ATLCONV_IMPL
  346.  
  347. #ifdef _WINGDI_
  348.  
  349. ATLINLINE ATLAPI_(LPDEVMODEA) AtlDevModeW2A(LPDEVMODEA lpDevModeA, LPDEVMODEW lpDevModeW)
  350. {
  351.     USES_CONVERSION;
  352.     if (lpDevModeW == NULL)
  353.         return NULL;
  354.     ATLASSERT(lpDevModeA != NULL);
  355.     AtlW2AHelper((LPSTR)lpDevModeA->dmDeviceName, lpDevModeW->dmDeviceName, 32*sizeof(char), _acp);
  356.     memcpy(&lpDevModeA->dmSpecVersion, &lpDevModeW->dmSpecVersion,
  357.         offsetof(DEVMODEA, dmFormName) - offsetof(DEVMODEA, dmSpecVersion));
  358.     AtlW2AHelper((LPSTR)lpDevModeA->dmFormName, lpDevModeW->dmFormName, 32*sizeof(char), _acp);
  359.     memcpy(&lpDevModeA->dmLogPixels, &lpDevModeW->dmLogPixels,
  360.         sizeof(DEVMODEA) - offsetof(DEVMODEA, dmLogPixels));
  361.     if (lpDevModeW->dmDriverExtra != 0)
  362.         memcpy(lpDevModeA+1, lpDevModeW+1, lpDevModeW->dmDriverExtra);
  363.     lpDevModeA->dmSize = sizeof(DEVMODEA);
  364.     return lpDevModeA;
  365. }
  366.  
  367. #endif //_WINGDI
  368.  
  369. //Prevent pulling in second time 
  370. #undef _ATLCONV_IMPL
  371.  
  372. #endif // _ATLCONV_IMPL
  373.  
  374.